Django==5.0.3
djangorestframework==3.14.0
django-cors-headers==4.3.1
django-htmx==1.18.0

# Empty file

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = 'django-insecure-your-secret-key-here-change-in-production'
DEBUG = True
ALLOWED_HOSTS = ['localhost', '127.0.0.1']

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'django_htmx',
    'core',
    'quiz',
    'analytics',
    'content',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django_htmx.middleware.HtmxMiddleware',
]

ROOT_URLCONF = 'quizzy_med.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                'core.context_processors.theme_processor',
                'core.context_processors.navigation_processor',
            ],
        },
    },
]

WSGI_APPLICATION = 'quizzy_med.wsgi.application'

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

AUTH_PASSWORD_VALIDATORS = [
    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
]

LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_TZ = True

STATIC_URL = 'static/'
STATICFILES_DIRS = [BASE_DIR / 'static']
STATIC_ROOT = BASE_DIR / 'staticfiles'

DEFAULT_AUTO_FIELD = 'django.db.AutoField'

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.TemplateHTMLRenderer',
    ],
}

LOGIN_URL = '/auth/login/'
LOGIN_REDIRECT_URL = '/'
LOGOUT_REDIRECT_URL = '/auth/login/'

from django.contrib import admin
from django.urls import path, include
from django.views.generic import TemplateView

urlpatterns = [
    path('admin/', admin.site.urls),
    path('auth/', include('core.urls')),
    path('api/', include('quiz.urls_api')),
    path('api/analytics/', include('analytics.urls_api')),
    path('api/content/', include('content.urls_api')),
    path('', include('core.urls_ui')),
    path('quiz/', include('quiz.urls_ui')),
    path('analytics/', include('analytics.urls_ui')),
    path('content/', include('content.urls_ui')),
    path('service-worker.js', TemplateView.as_view(
        template_name='service-worker.js',
        content_type='application/javascript'
    )),
]

import os
from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'quizzy_med.settings')
application = get_wsgi_application()

import os
from django.core.asgi import get_asgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'quizzy_med.settings')
application = get_asgi_application()

# Empty file

from django.apps import AppConfig

class CoreConfig(AppConfig):
    default_auto_field = 'django.db.AutoField'
    name = 'core'

python manage.py startapp core
python manage.py startapp quiz
python manage.py startapp analytics
python manage.py startapp content

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
from django.db.models import JSONField

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    theme = models.CharField(max_length=10, default='light', choices=[('light', 'Light'), ('dark', 'Dark')])
    last_active_block = models.ForeignKey('quiz.Block', on_delete=models.SET_NULL, null=True, blank=True)
    daily_goal = models.IntegerField(default=20)
    exam_mode_enabled = models.BooleanField(default=False)
    analytics_consent = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return f"{self.user.username}'s profile"

class UserSettings(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='settings')
    enable_sounds = models.BooleanField(default=True)
    enable_animations = models.BooleanField(default=True)
    reduced_motion = models.BooleanField(default=False)
    default_quiz_size = models.IntegerField(default=10)
    default_exam_size = models.IntegerField(default=50)
    review_mistakes_only = models.BooleanField(default=True)
    auto_advance = models.BooleanField(default=False)
    strict_timing = models.BooleanField(default=False)
    
    def __str__(self):
        return f"{self.user.username}'s settings"

class NavigationState(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='nav_state')
    current_path = models.CharField(max_length=255, default='/')
    previous_path = models.CharField(max_length=255, blank=True)
    breadcrumbs = JSONField(default=list)
    quiz_context = JSONField(default=dict, blank=True)
    exam_context = JSONField(default=dict, blank=True)
    last_updated = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return f"{self.user.username}'s navigation state"

# Generated by Django 5.0.3 on 2024-01-01 00:00:00

from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion


class Migration(migrations.Migration):

    initial = True

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='NavigationState',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('current_path', models.CharField(default='/', max_length=255)),
                ('previous_path', models.CharField(blank=True, max_length=255)),
                ('breadcrumbs', models.JSONField(default=list)),
                ('quiz_context', models.JSONField(default=dict)),
                ('exam_context', models.JSONField(default=dict)),
                ('last_updated', models.DateTimeField(auto_now=True)),
                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='nav_state', to=settings.AUTH_USER_MODEL)),
            ],
        ),
        migrations.CreateModel(
            name='UserProfile',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('theme', models.CharField(choices=[('light', 'Light'), ('dark', 'Dark')], default='light', max_length=10)),
                ('daily_goal', models.IntegerField(default=20)),
                ('exam_mode_enabled', models.BooleanField(default=False)),
                ('analytics_consent', models.BooleanField(default=True)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('updated_at', models.DateTimeField(auto_now=True)),
                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile', to=settings.AUTH_USER_MODEL)),
            ],
        ),
        migrations.CreateModel(
            name='UserSettings',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('enable_sounds', models.BooleanField(default=True)),
                ('enable_animations', models.BooleanField(default=True)),
                ('reduced_motion', models.BooleanField(default=False)),
                ('default_quiz_size', models.IntegerField(default=10)),
                ('default_exam_size', models.IntegerField(default=50)),
                ('review_mistakes_only', models.BooleanField(default=True)),
                ('auto_advance', models.BooleanField(default=False)),
                ('strict_timing', models.BooleanField(default=False)),
                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='settings', to=settings.AUTH_USER_MODEL)),
            ],
        ),
    ]

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User
from .models import UserProfile, UserSettings, NavigationState

class UserProfileInline(admin.StackedInline):
    model = UserProfile
    can_delete = False

class UserSettingsInline(admin.StackedInline):
    model = UserSettings
    can_delete = False

class CustomUserAdmin(UserAdmin):
    inlines = [UserProfileInline, UserSettingsInline]
    list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff', 'get_theme')
    
    def get_theme(self, obj):
        return obj.profile.theme if hasattr(obj, 'profile') else 'light'
    get_theme.short_description = 'Theme'

admin.site.unregister(User)
admin.site.register(User, CustomUserAdmin)

@admin.register(NavigationState)
class NavigationStateAdmin(admin.ModelAdmin):
    list_display = ('user', 'current_path', 'last_updated')
    readonly_fields = ('last_updated',)
    search_fields = ('user__username', 'current_path')

from django.urls import resolve, Resolver404
from .models import UserProfile, NavigationState

def theme_processor(request):
    if request.user.is_authenticated:
        try:
            profile = request.user.profile
            theme = profile.theme
        except UserProfile.DoesNotExist:
            theme = 'light'
    else:
        theme = 'light'
    
    return {'current_theme': theme}

def navigation_processor(request):
    if not request.user.is_authenticated:
        return {
            'nav_items': [],
            'breadcrumbs': [],
            'current_path': request.path,
            'is_mobile': False
        }
    
    try:
        nav_state = request.user.nav_state
        breadcrumbs = nav_state.breadcrumbs
    except NavigationState.DoesNotExist:
        breadcrumbs = []
    
    try:
        current_url_name = resolve(request.path_info).url_name
    except Resolver404:
        current_url_name = None
    
    user_agent = request.META.get('HTTP_USER_AGENT', '').lower()
    is_mobile = any(device in user_agent for device in ['mobile', 'android', 'iphone'])
    
    nav_items = [
        {'name': 'Home', 'url': '/', 'icon': 'home', 'active': request.path == '/'},
        {'name': 'Blocks', 'url': '/blocks/', 'icon': 'layers', 'active': request.path.startswith('/blocks')},
        {'name': 'Resume', 'url': '/quiz/resume/', 'icon': 'play', 'active': request.path == '/quiz/resume/', 'primary': True},
        {'name': 'Progress', 'url': '/analytics/', 'icon': 'trending-up', 'active': request.path.startswith('/analytics')},
        {'name': 'Editor', 'url': '/content/', 'icon': 'edit', 'active': request.path.startswith('/content'), 'staff_only': True},
        {'name': 'Profile', 'url': '/auth/profile/', 'icon': 'user', 'active': request.path.startswith('/auth/profile')},
    ]
    
    return {
        'nav_items': nav_items,
        'breadcrumbs': breadcrumbs,
        'current_path': request.path,
        'current_url_name': current_url_name,
        'is_mobile': is_mobile,
        'user_is_staff': request.user.is_staff,
    }

from django.shortcuts import render, redirect
from django.contrib.auth import login, logout, authenticate
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from django.contrib import messages
from django.views.decorators.http import require_http_methods
from django.http import JsonResponse
from .models import UserProfile, UserSettings, NavigationState
from quiz.models import UserQuestionState, Block
from quiz.engine.workload import get_todays_workload
import json

def home_view(request):
    if not request.user.is_authenticated:
        return render(request, 'core/landing.html')
    
    try:
        profile = request.user.profile
    except UserProfile.DoesNotExist:
        profile = UserProfile.objects.create(user=request.user)
    
    workload = get_todays_workload(request.user) if request.user.is_authenticated else None
    
    context = {
        'workload': workload,
        'recent_blocks': Block.objects.filter(is_active=True).order_by('-created_at')[:3],
        'stats': {
            'total_questions': UserQuestionState.objects.filter(user=request.user).count(),
            'correct_answers': UserQuestionState.objects.filter(user=request.user, last_correct=True).count(),
            'streak_days': 0,
        }
    }
    return render(request, 'core/home.html', context)

def login_view(request):
    if request.user.is_authenticated:
        return redirect('/')
    
    if request.method == 'POST':
        form = AuthenticationForm(request, data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(request, user)
            
            nav_state, created = NavigationState.objects.get_or_create(user=user)
            nav_state.current_path = '/'
            nav_state.breadcrumbs = []
            nav_state.save()
            
            next_url = request.GET.get('next', '/')
            return redirect(next_url)
    else:
        form = AuthenticationForm()
    
    return render(request, 'core/auth/login.html', {'form': form})

def register_view(request):
    if request.user.is_authenticated:
        return redirect('/')
    
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            
            UserProfile.objects.create(user=user)
            UserSettings.objects.create(user=user)
            NavigationState.objects.create(user=user)
            
            login(request, user)
            messages.success(request, 'Account created successfully!')
            return redirect('/')
    else:
        form = UserCreationForm()
    
    return render(request, 'core/auth/register.html', {'form': form})

@login_required
def logout_view(request):
    logout(request)
    return redirect('/auth/login/')

@login_required
def profile_view(request):
    profile = request.user.profile
    settings = request.user.settings
    
    if request.method == 'POST':
        theme = request.POST.get('theme')
        if theme in ['light', 'dark']:
            profile.theme = theme
            profile.save()
            messages.success(request, 'Theme updated')
        
        daily_goal = request.POST.get('daily_goal')
        if daily_goal and daily_goal.isdigit():
            profile.daily_goal = int(daily_goal)
            profile.save()
        
        enable_animations = request.POST.get('enable_animations')
        settings.enable_animations = enable_animations == 'on'
        settings.save()
        
        return redirect('/auth/profile/')
    
    return render(request, 'core/profile.html', {
        'profile': profile,
        'settings': settings
    })

@login_required
@require_http_methods(['POST'])
def update_theme_view(request):
    theme = request.POST.get('theme')
    if theme not in ['light', 'dark']:
        return JsonResponse({'error': 'Invalid theme'}, status=400)
    
    profile = request.user.profile
    profile.theme = theme
    profile.save()
    
    return JsonResponse({'success': True, 'theme': theme})

@login_required
def get_workload_view(request):
    workload = get_todays_workload(request.user)
    return JsonResponse(workload)

@login_required
def update_navigation_view(request):
    if request.method == 'POST':
        nav_state = request.user.nav_state
        data = json.loads(request.body)
        
        nav_state.current_path = data.get('current_path', nav_state.current_path)
        nav_state.previous_path = data.get('previous_path', nav_state.previous_path)
        
        if 'breadcrumbs' in data:
            nav_state.breadcrumbs = data['breadcrumbs']
        
        nav_state.save()
        return JsonResponse({'success': True})
    
    return JsonResponse({'error': 'Method not allowed'}, status=405)

from django.urls import path
from . import views

urlpatterns = [
    path('login/', views.login_view, name='login'),
    path('register/', views.register_view, name='register'),
    path('logout/', views.logout_view, name='logout'),
]

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home_view, name='home'),
    path('auth/profile/', views.profile_view, name='profile'),
    path('api/update-theme/', views.update_theme_view, name='update_theme'),
    path('api/get-workload/', views.get_workload_view, name='get_workload'),
    path('api/update-navigation/', views.update_navigation_view, name='update_navigation'),
]

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
from django.db.models import JSONField
import uuid

class Block(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    title = models.CharField(max_length=200)
    code = models.CharField(max_length=20, unique=True)
    description = models.TextField(blank=True)
    duration_weeks = models.IntegerField(default=4)
    is_active = models.BooleanField(default=True)
    order = models.IntegerField(default=0)
    prerequisites = models.ManyToManyField('self', symmetrical=False, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        ordering = ['order', 'created_at']
    
    def __str__(self):
        return f"{self.code}: {self.title}"

class Topic(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    block = models.ForeignKey(Block, on_delete=models.CASCADE, related_name='topics')
    title = models.CharField(max_length=200)
    code = models.CharField(max_length=50)
    description = models.TextField(blank=True)
    order = models.IntegerField(default=0)
    question_count = models.IntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        ordering = ['order', 'created_at']
        unique_together = ['block', 'code']
    
    def __str__(self):
        return f"{self.block.code}.{self.code}: {self.title}"

class Question(models.Model):
    DIFFICULTY_CHOICES = [
        ('easy', 'Easy'),
        ('medium', 'Medium'),
        ('hard', 'Hard'),
        ('very_hard', 'Very Hard'),
    ]
    
    QUESTION_TYPE_CHOICES = [
        ('single', 'Single Correct Answer'),
        ('multiple', 'Multiple Correct Answers'),
        ('true_false', 'True/False'),
    ]
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    topic = models.ForeignKey(Topic, on_delete=models.CASCADE, related_name='questions')
    question_text = models.TextField()
    explanation = models.TextField(blank=True)
    difficulty = models.CharField(max_length=20, choices=DIFFICULTY_CHOICES, default='medium')
    question_type = models.CharField(max_length=20, choices=QUESTION_TYPE_CHOICES, default='single')
    is_active = models.BooleanField(default=True)
    tags = JSONField(default=list, blank=True)
    references = JSONField(default=list, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        ordering = ['topic__order', 'created_at']
    
    def __str__(self):
        return f"Q: {self.question_text[:50]}..."

class Option(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='options')
    option_text = models.TextField()
    is_correct = models.BooleanField(default=False)
    order = models.IntegerField(default=0)
    explanation = models.TextField(blank=True)
    
    class Meta:
        ordering = ['order']
    
    def __str__(self):
        return f"Option {self.order}: {self.option_text[:30]}"

class UserBlockProgress(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='block_progress')
    block = models.ForeignKey(Block, on_delete=models.CASCADE, related_name='user_progress')
    is_enrolled = models.BooleanField(default=True)
    enrolled_at = models.DateTimeField(auto_now_add=True)
    completed_at = models.DateTimeField(null=True, blank=True)
    current_week = models.IntegerField(default=1)
    mastery_score = models.FloatField(default=0.0)
    last_activity = models.DateTimeField(auto_now=True)
    
    class Meta:
        unique_together = ['user', 'block']
    
    def __str__(self):
        return f"{self.user.username} - {self.block.code}"

class UserQuestionState(models.Model):
    CONFIDENCE_CHOICES = [
        ('guess', 'Guessed'),
        ('unsure', 'Unsure'),
        ('sure', 'Sure'),
    ]
    
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='question_states')
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='user_states')
    easiness = models.FloatField(default=2.5)
    interval = models.IntegerField(default=1)
    repetitions = models.IntegerField(default=0)
    next_review = models.DateTimeField(default=timezone.now)
    last_reviewed = models.DateTimeField(null=True, blank=True)
    last_correct = models.BooleanField(default=False)
    last_confidence = models.CharField(max_length=10, choices=CONFIDENCE_CHOICES, null=True, blank=True)
    streak_correct = models.IntegerField(default=0)
    streak_incorrect = models.IntegerField(default=0)
    total_correct = models.IntegerField(default=0)
    total_attempts = models.IntegerField(default=0)
    avg_response_time = models.FloatField(default=0.0)
    block_context = models.ForeignKey(Block, on_delete=models.SET_NULL, null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    class Meta:
        unique_together = ['user', 'question']
        indexes = [
            models.Index(fields=['user', 'next_review']),
            models.Index(fields=['user', 'question', 'last_correct']),
        ]
    
    def __str__(self):
        return f"{self.user.username} - Q{self.question.id}"

class QuizSession(models.Model):
    SESSION_TYPES = [
        ('learning', 'Learning Session'),
        ('review', 'Review Session'),
        ('exam', 'Exam Simulation'),
        ('mistakes', 'Mistakes Only'),
    ]
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='quiz_sessions')
    session_type = models.CharField(max_length=20, choices=SESSION_TYPES)
    block = models.ForeignKey(Block, on_delete=models.SET_NULL, null=True, blank=True)
    topic = models.ForeignKey(Topic, on_delete=models.SET_NULL, null=True, blank=True)
    is_completed = models.BooleanField(default=False)
    is_abandoned = models.BooleanField(default=False)
    total_questions = models.IntegerField(default=0)
    correct_answers = models.IntegerField(default=0)
    current_question_index = models.IntegerField(default=0)
    settings = JSONField(default=dict)
    started_at = models.DateTimeField(auto_now_add=True)
    completed_at = models.DateTimeField(null=True, blank=True)
    
    class Meta:
        ordering = ['-started_at']
    
    def __str__(self):
        return f"{self.user.username} - {self.session_type} - {self.started_at}"

class QuizQuestion(models.Model):
    session = models.ForeignKey(QuizSession, on_delete=models.CASCADE, related_name='quiz_questions')
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='quiz_appearances')
    order = models.IntegerField(default=0)
    user_answer = JSONField(default=list, blank=True)
    is_answered = models.BooleanField(default=False)
    is_correct = models.BooleanField(default=False)
    response_time = models.FloatField(default=0.0)
    confidence = models.CharField(max_length=10, choices=UserQuestionState.CONFIDENCE_CHOICES, null=True, blank=True)
    reviewed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        ordering = ['order']
        unique_together = ['session', 'question']
    
    def __str__(self):
        return f"QQ {self.order}: Session {self.session.id}"

class Attempt(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='attempts')
    question = models.ForeignKey(Question, on_delete=models.CASCADE, related_name='attempts')
    session = models.ForeignKey(QuizSession, on_delete=models.SET_NULL, null=True, blank=True)
    user_answer = JSONField(default=list)
    is_correct = models.BooleanField()
    confidence = models.CharField(max_length=10, choices=UserQuestionState.CONFIDENCE_CHOICES)
    response_time = models.FloatField()
    block_context = models.ForeignKey(Block, on_delete=models.SET_NULL, null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        ordering = ['-created_at']
        indexes = [
            models.Index(fields=['user', 'created_at']),
            models.Index(fields=['question', 'is_correct']),
        ]
    
    def __str__(self):
        return f"Attempt: {self.user.username} - {'Correct' if self.is_correct else 'Incorrect'}"

# Generated by Django 5.0.3 on 2024-01-01 00:00:00

from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import uuid


class Migration(migrations.Migration):

    initial = True

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='Block',
            fields=[
                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ('title', models.CharField(max_length=200)),
                ('code', models.CharField(max_length=20, unique=True)),
                ('description', models.TextField(blank=True)),
                ('duration_weeks', models.IntegerField(default=4)),
                ('is_active', models.BooleanField(default=True)),
                ('order', models.IntegerField(default=0)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('updated_at', models.DateTimeField(auto_now=True)),
                ('prerequisites', models.ManyToManyField(blank=True, to='quiz.block')),
            ],
            options={
                'ordering': ['order', 'created_at'],
            },
        ),
        migrations.CreateModel(
            name='Question',
            fields=[
                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ('question_text', models.TextField()),
                ('explanation', models.TextField(blank=True)),
                ('difficulty', models.CharField(choices=[('easy', 'Easy'), ('medium', 'Medium'), ('hard', 'Hard'), ('very_hard', 'Very Hard')], default='medium', max_length=20)),
                ('question_type', models.CharField(choices=[('single', 'Single Correct Answer'), ('multiple', 'Multiple Correct Answers'), ('true_false', 'True/False')], default='single', max_length=20)),
                ('is_active', models.BooleanField(default=True)),
                ('tags', models.JSONField(blank=True, default=list)),
                ('references', models.JSONField(blank=True, default=list)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('updated_at', models.DateTimeField(auto_now=True)),
            ],
            options={
                'ordering': ['topic__order', 'created_at'],
            },
        ),
        migrations.CreateModel(
            name='QuizSession',
            fields=[
                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ('session_type', models.CharField(choices=[('learning', 'Learning Session'), ('review', 'Review Session'), ('exam', 'Exam Simulation'), ('mistakes', 'Mistakes Only')], max_length=20)),
                ('is_completed', models.BooleanField(default=False)),
                ('is_abandoned', models.BooleanField(default=False)),
                ('total_questions', models.IntegerField(default=0)),
                ('correct_answers', models.IntegerField(default=0)),
                ('current_question_index', models.IntegerField(default=0)),
                ('settings', models.JSONField(default=dict)),
                ('started_at', models.DateTimeField(auto_now_add=True)),
                ('completed_at', models.DateTimeField(blank=True, null=True)),
                ('block', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='quiz.block')),
            ],
            options={
                'ordering': ['-started_at'],
            },
        ),
        migrations.CreateModel(
            name='Topic',
            fields=[
                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ('title', models.CharField(max_length=200)),
                ('code', models.CharField(max_length=50)),
                ('description', models.TextField(blank=True)),
                ('order', models.IntegerField(default=0)),
                ('question_count', models.IntegerField(default=0)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('updated_at', models.DateTimeField(auto_now=True)),
                ('block', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='topics', to='quiz.block')),
            ],
            options={
                'ordering': ['order', 'created_at'],
                'unique_together': {('block', 'code')},
            },
        ),
        migrations.CreateModel(
            name='UserQuestionState',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('easiness', models.FloatField(default=2.5)),
                ('interval', models.IntegerField(default=1)),
                ('repetitions', models.IntegerField(default=0)),
                ('next_review', models.DateTimeField(default=django.utils.timezone.now)),
                ('last_reviewed', models.DateTimeField(blank=True, null=True)),
                ('last_correct', models.BooleanField(default=False)),
                ('last_confidence', models.CharField(blank=True, choices=[('guess', 'Guessed'), ('unsure', 'Unsure'), ('sure', 'Sure')], max_length=10, null=True)),
                ('streak_correct', models.IntegerField(default=0)),
                ('streak_incorrect', models.IntegerField(default=0)),
                ('total_correct', models.IntegerField(default=0)),
                ('total_attempts', models.IntegerField(default=0)),
                ('avg_response_time', models.FloatField(default=0.0)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('updated_at', models.DateTimeField(auto_now=True)),
                ('block', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='quiz.block')),
                ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_states', to='quiz.question')),
                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='question_states', to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'unique_together': {('user', 'question')},
            },
        ),
        migrations.AddField(
            model_name='question',
            name='topic',
            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='questions', to='quiz.topic'),
        ),
        migrations.CreateModel(
            name='QuizQuestion',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('order', models.IntegerField(default=0)),
                ('user_answer', models.JSONField(blank=True, default=list)),
                ('is_answered', models.BooleanField(default=False)),
                ('is_correct', models.BooleanField(default=False)),
                ('response_time', models.FloatField(default=0.0)),
                ('confidence', models.CharField(blank=True, choices=[('guess', 'Guessed'), ('unsure', 'Unsure'), ('sure', 'Sure')], max_length=10, null=True)),
                ('reviewed', models.BooleanField(default=False)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='quiz_appearances', to='quiz.question')),
                ('session', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='quiz_questions', to='quiz.quizsession')),
            ],
            options={
                'ordering': ['order'],
                'unique_together': {('session', 'question')},
            },
        ),
        migrations.AddField(
            model_name='quizsession',
            name='topic',
            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='quiz.topic'),
        ),
        migrations.AddField(
            model_name='quizsession',
            name='user',
            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='quiz_sessions', to=settings.AUTH_USER_MODEL),
        ),
        migrations.CreateModel(
            name='Option',
            fields=[
                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
                ('option_text', models.TextField()),
                ('is_correct', models.BooleanField(default=False)),
                ('order', models.IntegerField(default=0)),
                ('explanation', models.TextField(blank=True)),
                ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='options', to='quiz.question')),
            ],
            options={
                'ordering': ['order'],
            },
        ),
        migrations.CreateModel(
            name='UserBlockProgress',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('is_enrolled', models.BooleanField(default=True)),
                ('enrolled_at', models.DateTimeField(auto_now_add=True)),
                ('completed_at', models.DateTimeField(blank=True, null=True)),
                ('current_week', models.IntegerField(default=1)),
                ('mastery_score', models.FloatField(default=0.0)),
                ('last_activity', models.DateTimeField(auto_now=True)),
                ('block', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_progress', to='quiz.block')),
                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='block_progress', to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'unique_together': {('user', 'block')},
            },
        ),
        migrations.CreateModel(
            name='Attempt',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('user_answer', models.JSONField(default=list)),
                ('is_correct', models.BooleanField()),
                ('confidence', models.CharField(choices=[('guess', 'Guessed'), ('unsure', 'Unsure'), ('sure', 'Sure')], max_length=10)),
                ('response_time', models.FloatField()),
                ('created_at', models.DateTimeField(auto_now_add=True)),
                ('block', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='quiz.block')),
                ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='attempts', to='quiz.question')),
                ('session', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='quiz.quizsession')),
                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='attempts', to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'ordering': ['-created_at'],
            },
        ),
        migrations.AddIndex(
            model_name='userquestionstate',
            index=models.Index(fields=['user', 'next_review'], name='quiz_userqu_user_id_3ef34f_idx'),
        ),
        migrations.AddIndex(
            model_name='userquestionstate',
            index=models.Index(fields=['user', 'question', 'last_correct'], name='quiz_userqu_user_id_9cff05_idx'),
        ),
        migrations.AddIndex(
            model_name='attempt',
            index=models.Index(fields=['user', 'created_at'], name='quiz_attempt_user_id_80111c_idx'),
        ),
        migrations.AddIndex(
            model_name='attempt',
            index=models.Index(fields=['question', 'is_correct'], name='quiz_attempt_questio_e823d1_idx'),
        ),
    ]

from django.contrib import admin
from .models import Block, Topic, Question, Option, UserBlockProgress, UserQuestionState, QuizSession, QuizQuestion, Attempt

class OptionInline(admin.TabularInline):
    model = Option
    extra = 4

class QuestionAdmin(admin.ModelAdmin):
    list_display = ('id', 'topic', 'difficulty', 'question_type', 'is_active')
    list_filter = ('difficulty', 'question_type', 'is_active', 'topic__block')
    search_fields = ('question_text', 'explanation')
    inlines = [OptionInline]
    raw_id_fields = ('topic',)

class TopicAdmin(admin.ModelAdmin):
    list_display = ('code', 'title', 'block', 'order', 'question_count')
    list_filter = ('block',)
    search_fields = ('title', 'code', 'description')
    raw_id_fields = ('block',)

class BlockAdmin(admin.ModelAdmin):
    list_display = ('code', 'title', 'duration_weeks', 'is_active', 'order')
    list_filter = ('is_active',)
    search_fields = ('title', 'code', 'description')
    filter_horizontal = ('prerequisites',)

class UserQuestionStateAdmin(admin.ModelAdmin):
    list_display = ('user', 'question', 'last_correct', 'next_review', 'repetitions')
    list_filter = ('last_correct', 'last_confidence', 'block')
    search_fields = ('user__username', 'question__question_text')
    raw_id_fields = ('user', 'question')

class QuizSessionAdmin(admin.ModelAdmin):
    list_display = ('user', 'session_type', 'block', 'is_completed', 'started_at')
    list_filter = ('session_type', 'is_completed', 'is_abandoned')
    search_fields = ('user__username', 'block__title')
    raw_id_fields = ('user', 'block', 'topic')

admin.site.register(Block, BlockAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Question, QuestionAdmin)
admin.site.register(UserBlockProgress)
admin.site.register(UserQuestionState, UserQuestionStateAdmin)
admin.site.register(QuizSession, QuizSessionAdmin)
admin.site.register(QuizQuestion)
admin.site.register(Attempt)

# Empty file

"""
Modified SM-2 algorithm with confidence weighting and error-weighted prioritization.
Based on: SuperMemo 2 algorithm with medical education optimizations.
"""

import math
from datetime import datetime, timedelta
from typing import Dict, List, Tuple, Optional

class SM2Scheduler:
    """
    Modified SM-2 scheduler for medical MCQ learning.
    
    Key modifications:
    1. Confidence weighting (guess/unsure/sure) affects interval growth
    2. Error-weighted prioritization for difficult questions
    3. Block-aware scheduling for 4-week academic blocks
    4. Post-block retention scheduling
    5. Adaptive session sizing based on performance
    """
    
    # Base intervals for first review (in days)
    BASE_INTERVALS = {
        'guess': 1,    # If guessed, review next day
        'unsure': 1,   # If unsure, review next day
        'sure': 3,     # If sure, review in 3 days
    }
    
    # Confidence multipliers for interval growth
    CONFIDENCE_MULTIPLIERS = {
        'guess': 1.2,   # Slower growth if guessed
        'unsure': 1.5,  # Moderate growth if unsure
        'sure': 2.0,    # Faster growth if sure
    }
    
    # Difficulty penalties (applied to easiness factor)
    DIFFICULTY_PENALTIES = {
        'easy': 0.0,
        'medium': -0.1,
        'hard': -0.3,
        'very_hard': -0.5,
    }
    
    # Error weights for prioritization
    ERROR_WEIGHTS = {
        'streak_incorrect': 0.3,
        'total_attempts': 0.1,
        'avg_response_time': 0.1,
        'difficulty': 0.5,
    }
    
    @staticmethod
    def calculate_next_review(
        current_state: Dict,
        is_correct: bool,
        confidence: str,
        difficulty: str,
        response_time: float,
        block_week: Optional[int] = None
    ) -> Dict:
        """
        Calculate next review parameters using modified SM-2.
        
        Args:
            current_state: Current question state with keys:
                - easiness (float): Current easiness factor
                - interval (int): Current interval in days
                - repetitions (int): Number of successful repetitions
                - streak_correct (int): Current correct streak
                - streak_incorrect (int): Current incorrect streak
                - total_attempts (int): Total attempts
                - total_correct (int): Total correct attempts
                - avg_response_time (float): Average response time
            is_correct: Whether the answer was correct
            confidence: 'guess', 'unsure', or 'sure'
            difficulty: Question difficulty level
            response_time: Time taken to answer in seconds
            block_week: Current week in block (1-4), None for post-block
        
        Returns:
            Updated state dictionary with new scheduling parameters
        """
        # Initialize with current state
        new_state = current_state.copy()
        
        # Update attempt statistics
        new_state['total_attempts'] += 1
        if is_correct:
            new_state['total_correct'] += 1
            new_state['streak_correct'] += 1
            new_state['streak_incorrect'] = 0
        else:
            new_state['streak_correct'] = 0
            new_state['streak_incorrect'] += 1
        
        # Update average response time (exponential moving average)
        alpha = 0.3  # Learning rate for response time
        current_avg = new_state.get('avg_response_time', response_time)
        new_state['avg_response_time'] = (alpha * response_time + 
                                          (1 - alpha) * current_avg)
        
        # Calculate quality (0-5 scale as in original SM-2, adjusted for confidence)
        if not is_correct:
            quality = 0  # Complete failure
        else:
            # Map confidence to quality (3-5 range for correct answers)
            quality_map = {'guess': 3, 'unsure': 4, 'sure': 5}
            quality = quality_map.get(confidence, 4)
            
            # Adjust quality based on response time (faster = higher quality)
            time_penalty = min(response_time / 30.0, 1.0)  # Normalize to 30 seconds
            quality = max(3, quality - time_penalty)
        
        # Update easiness factor (EF)
        ef = new_state.get('easiness', 2.5)
        
        if quality >= 3:  # Correct answer
            # Standard SM-2 easiness update
            ef = ef + (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02))
            
            # Apply difficulty penalty
            difficulty_penalty = SM2Scheduler.DIFFICULTY_PENALTIES.get(difficulty, 0.0)
            ef += difficulty_penalty
            
            # Apply error-weighted adjustment for difficult questions
            if new_state.get('streak_incorrect', 0) > 2:
                # Reduce easiness growth for historically difficult questions
                ef = max(1.3, ef * 0.9)
        else:  # Incorrect answer
            # Reset easiness more aggressively for incorrect answers
            ef = max(1.3, ef - 0.2)
            new_state['repetitions'] = 0
        
        # Bound easiness factor
        ef = max(1.3, min(ef, 2.5))
        new_state['easiness'] = round(ef, 2)
        
        # Calculate next interval
        if not is_correct:
            # Reset interval for incorrect answers
            new_state['interval'] = SM2Scheduler.BASE_INTERVALS['guess']
            new_state['repetitions'] = 0
        else:
            # Update repetitions and interval
            if quality >= 3:  # Correct answer
                repetitions = new_state.get('repetitions', 0)
                
                if repetitions == 0:
                    interval = SM2Scheduler.BASE_INTERVALS.get(confidence, 1)
                elif repetitions == 1:
                    interval = 6  # 6 days for second repetition
                else:
                    # Apply confidence-based multiplier
                    multiplier = SM2Scheduler.CONFIDENCE_MULTIPLIERS.get(confidence, 1.5)
                    interval = math.ceil(new_state.get('interval', 1) * ef * multiplier)
                
                # Apply block-aware scheduling if within a block
                if block_week and 1 <= block_week <= 4:
                    interval = SM2Scheduler._apply_block_scheduling(
                        interval, block_week, repetitions, confidence
                    )
                
                new_state['repetitions'] = repetitions + 1
                new_state['interval'] = min(interval, 365)  # Cap at 1 year
            else:
                new_state['interval'] = 1
                new_state['repetitions'] = 0
        
        # Calculate priority score for error-weighted prioritization
        priority_score = SM2Scheduler._calculate_priority_score(new_state, difficulty)
        new_state['priority_score'] = priority_score
        
        return new_state
    
    @staticmethod
    def _apply_block_scheduling(
        interval: int,
        block_week: int,
        repetitions: int,
        confidence: str
    ) -> int:
        """
        Adjust intervals based on block week for intensive learning.
        
        During 4-week blocks:
        - Week 1-3: More frequent reviews (capped intervals)
        - Week 4: Prepare for end-of-block exam
        - Post-block: Normal scheduling resumes
        """
        if block_week <= 3:
            # During block learning phase, cap intervals
            max_interval_by_week = {
                1: 2,   # Week 1: max 2 days
                2: 4,   # Week 2: max 4 days
                3: 7,   # Week 3: max 7 days
            }
            return min(interval, max_interval_by_week.get(block_week, 7))
        
        elif block_week == 4:
            # Week 4: Prepare for exam (shorter intervals for exam prep)
            if confidence == 'guess':
                return 1
            elif confidence == 'unsure':
                return 2
            else:
                return min(interval, 3)
        
        return interval
    
    @staticmethod
    def _calculate_priority_score(state: Dict, difficulty: str) -> float:
        """
        Calculate error-weighted priority score for question ordering.
        
        Higher score = higher priority for review.
        """
        score = 0.0
        
        # Streak incorrect weight
        streak_incorrect = state.get('streak_incorrect', 0)
        score += streak_incorrect * SM2Scheduler.ERROR_WEIGHTS['streak_incorrect']
        
        # Total attempts weight (more attempts = lower priority)
        total_attempts = state.get('total_attempts', 0)
        if total_attempts > 0:
            success_rate = state.get('total_correct', 0) / total_attempts
            score += (1 - success_rate) * SM2Scheduler.ERROR_WEIGHTS['total_attempts']
        
        # Response time weight (slower = higher priority)
        avg_time = state.get('avg_response_time', 0)
        if avg_time > 0:
            # Normalize: >30 seconds = high priority
            time_score = min(avg_time / 30.0, 2.0)
            score += time_score * SM2Scheduler.ERROR_WEIGHTS['avg_response_time']
        
        # Difficulty weight
        difficulty_score = {
            'easy': 0.1,
            'medium': 0.3,
            'hard': 0.7,
            'very_hard': 1.0,
        }.get(difficulty, 0.5)
        score += difficulty_score * SM2Scheduler.ERROR_WEIGHTS['difficulty']
        
        # Age weight (older incorrect answers get higher priority)
        last_correct = state.get('last_correct', False)
        if not last_correct:
            repetitions = state.get('repetitions', 0)
            score += (repetitions * 0.1)  # More repetitions without mastery = higher priority
        
        return round(score, 3)
    
    @staticmethod
    def calculate_next_review_date(
        current_date: datetime,
        interval: int,
        block_end_date: Optional[datetime] = None
    ) -> datetime:
        """
        Calculate exact next review date with optional block constraints.
        """
        next_date = current_date + timedelta(days=interval)
        
        # Ensure reviews don't extend beyond block end during block learning
        if block_end_date and next_date > block_end_date:
            # Schedule for last day of block for final review
            return block_end_date
        
        return next_date

"""
Workload calculation for daily due questions.
"""

from datetime import datetime, timedelta
from typing import Dict, List, Tuple
from django.utils import timezone
from django.db.models import Q
from ..models import UserQuestionState, Block, UserBlockProgress

def get_todays_workload(user) -> Dict:
    """
    Calculate today's due workload for a user.
    
    Returns:
        Dictionary with workload information
    """
    today = timezone.now().date()
    
    # Get all due questions
    due_states = UserQuestionState.objects.filter(
        user=user,
        next_review__date__lte=today
    ).select_related('question', 'question__topic', 'question__topic__block')
    
    # Separate by block and priority
    block_workload = {}
    total_questions = 0
    high_priority = 0
    medium_priority = 0
    low_priority = 0
    
    for state in due_states:
        block = state.block_context
        if not block:
            # Try to get block from question
            block = state.question.topic.block if state.question.topic else None
        
        if block:
            block_id = str(block.id)
            if block_id not in block_workload:
                block_workload[block_id] = {
                    'block': block,
                    'count': 0,
                    'high_priority': 0,
                    'medium_priority': 0,
                    'low_priority': 0
                }
            
            # Determine priority based on state
            priority = _get_question_priority(state)
            block_workload[block_id]['count'] += 1
            
            if priority == 'high':
                block_workload[block_id]['high_priority'] += 1
                high_priority += 1
            elif priority == 'medium':
                block_workload[block_id]['medium_priority'] += 1
                medium_priority += 1
            else:
                block_workload[block_id]['low_priority'] += 1
                low_priority += 1
        
        total_questions += 1
    
    # Calculate estimated time (assuming 1-2 minutes per question)
    estimated_minutes = total_questions * 1.5
    
    # Check for overdue workload (questions overdue by > 2 days)
    two_days_ago = today - timedelta(days=2)
    overdue_states = UserQuestionState.objects.filter(
        user=user,
        next_review__date__lt=two_days_ago
    ).count()
    
    # Get current block progress
    current_block = None
    try:
        profile = user.profile
        current_block = profile.last_active_block
    except:
        pass
    
    # Get enrolled blocks
    enrolled_blocks = UserBlockProgress.objects.filter(
        user=user,
        is_enrolled=True
    ).select_related('block')
    
    return {
        'total_due': total_questions,
        'high_priority': high_priority,
        'medium_priority': medium_priority,
        'low_priority': low_priority,
        'estimated_minutes': estimated_minutes,
        'overdue_count': overdue_states,
        'is_overdue': overdue_states > 0,
        'block_workload': list(block_workload.values()),
        'current_block': current_block,
        'enrolled_blocks': list(enrolled_blocks.values('block__id', 'block__title', 'current_week', 'mastery_score')),
        'last_updated': timezone.now().isoformat()
    }

def _get_question_priority(state) -> str:
    """
    Determine priority level for a question based on its state.
    """
    # High priority criteria
    if (state.streak_incorrect >= 2 or 
        (state.last_correct is False and state.repetitions == 0) or
        state.priority_score > 1.0):
        return 'high'
    
    # Medium priority criteria
    elif (state.streak_incorrect == 1 or
          (state.last_correct is True and state.confidence in ['guess', 'unsure']) or
          state.priority_score > 0.5):
        return 'medium'
    
    # Low priority
    else:
        return 'low'

def get_block_workload(user, block_id: str) -> Dict:
    """
    Get workload for a specific block.
    """
    try:
        block = Block.objects.get(id=block_id)
    except Block.DoesNotExist:
        return {}
    
    today = timezone.now().date()
    
    # Get due questions in this block
    due_states = UserQuestionState.objects.filter(
        user=user,
        next_review__date__lte=today,
        block_context=block
    ).count()
    
    # Get all questions in block
    total_questions = UserQuestionState.objects.filter(
        user=user,
        question__topic__block=block
    ).count()
    
    # Get block progress
    try:
        progress = UserBlockProgress.objects.get(user=user, block=block)
        current_week = progress.current_week
        mastery_score = progress.mastery_score
    except UserBlockProgress.DoesNotExist:
        current_week = 1
        mastery_score = 0.0
    
    return {
        'block': {
            'id': str(block.id),
            'title': block.title,
            'code': block.code
        },
        'due_count': due_states,
        'total_questions': total_questions,
        'current_week': current_week,
        'mastery_score': mastery_score,
        'estimated_time': due_states * 1.5  # minutes
    }

"""
Quiz session composition logic.
"""

import random
from datetime import datetime, timedelta
from typing import List, Dict, Optional, Tuple
from django.utils import timezone
from django.db.models import Q, Count, Avg, F
from ..models import (
    Question, UserQuestionState, Block, Topic,
    UserBlockProgress, QuizSession, QuizQuestion
)
from .sm2 import SM2Scheduler

class SessionComposer:
    """
    Composes quiz sessions based on learning objectives and user state.
    """
    
    @staticmethod
    def compose_learning_session(
        user,
        block_id: Optional[str] = None,
        topic_id: Optional[str] = None,
        size: int = 10,
        include_new: bool = True
    ) -> List[Question]:
        """
        Compose a learning session with mixed question types.
        
        Priority order:
        1. High priority due questions
        2. Medium priority due questions
        3. New questions (if include_new)
        4. Low priority due questions
        """
        today = timezone.now().date()
        
        # Base query for user's question states
        base_qs = UserQuestionState.objects.filter(user=user)
        
        # Apply block/topic filters
        if block_id:
            base_qs = base_qs.filter(block_context_id=block_id)
        if topic_id:
            base_qs = base_qs.filter(question__topic_id=topic_id)
        
        # Get due questions
        due_states = base_qs.filter(
            next_review__date__lte=today
        ).select_related('question').order_by('-priority_score')
        
        # Categorize by priority
        high_priority = []
        medium_priority = []
        low_priority = []
        
        for state in due_states:
            priority = _get_question_priority_from_state(state)
            if priority == 'high':
                high_priority.append(state.question)
            elif priority == 'medium':
                medium_priority.append(state.question)
            else:
                low_priority.append(state.question)
        
        # Select questions based on priority
        selected_questions = []
        
        # Add high priority (up to 40% of session)
        high_count = min(len(high_priority), int(size * 0.4))
        selected_questions.extend(random.sample(high_priority, high_count) if high_priority else [])
        
        # Add medium priority (up to 40% of session)
        medium_needed = int(size * 0.4) - len(selected_questions)
        if medium_needed > 0 and medium_priority:
            medium_count = min(len(medium_priority), medium_needed)
            selected_questions.extend(random.sample(medium_priority, medium_count))
        
        # Add new questions if requested
        if include_new and len(selected_questions) < size:
            new_questions = SessionComposer._get_new_questions(
                user, block_id, topic_id, size - len(selected_questions)
            )
            selected_questions.extend(new_questions)
        
        # Fill remaining with low priority
        if len(selected_questions) < size and low_priority:
            low_needed = size - len(selected_questions)
            low_count = min(len(low_priority), low_needed)
            selected_questions.extend(random.sample(low_priority, low_count))
        
        # If still not enough, get random questions from block/topic
        if len(selected_questions) < size:
            remaining = size - len(selected_questions)
            extra_questions = SessionComposer._get_random_questions(
                user, block_id, topic_id, remaining
            )
            selected_questions.extend(extra_questions)
        
        return selected_questions[:size]
    
    @staticmethod
    def compose_exam_session(
        user,
        block_id: str,
        size: int = 50
    ) -> List[Question]:
        """
        Compose an exam simulation session.
        
        Exam composition:
        - 40% from current week
        - 30% from previous week
        - 20% from two weeks ago
        - 10% from three weeks ago
        """
        try:
            progress = UserBlockProgress.objects.get(user=user, block_id=block_id)
            current_week = progress.current_week
        except UserBlockProgress.DoesNotExist:
            current_week = 1
        
        # Get questions from the block
        block_questions = Question.objects.filter(
            topic__block_id=block_id,
            is_active=True
        ).select_related('topic')
        
        # Separate by relative week
        questions_by_week = {1: [], 2: [], 3: [], 4: []}
        
        for question in block_questions:
            # Simple heuristic: use topic order to simulate week progression
            topic_week = ((question.topic.order - 1) // 4) + 1  # Assuming 4 topics per week
            relative_week = current_week - topic_week + 1
            
            if 1 <= relative_week <= 4:
                questions_by_week[relative_week].append(question)
        
        # Select questions based on exam distribution
        selected_questions = []
        
        # Current week (40%)
        current_week_count = int(size * 0.4)
        current_week_questions = questions_by_week.get(1, [])
        if len(current_week_questions) > current_week_count:
            selected_questions.extend(random.sample(current_week_questions, current_week_count))
        else:
            selected_questions.extend(current_week_questions)
        
        # Previous week (30%)
        prev_week_count = int(size * 0.3)
        prev_week_questions = questions_by_week.get(2, [])
        if len(prev_week_questions) > prev_week_count:
            selected_questions.extend(random.sample(prev_week_questions, prev_week_count))
        else:
            selected_questions.extend(prev_week_questions)
        
        # Two weeks ago (20%)
        two_weeks_count = int(size * 0.2)
        two_weeks_questions = questions_by_week.get(3, [])
        if len(two_weeks_questions) > two_weeks_count:
            selected_questions.extend(random.sample(two_weeks_questions, two_weeks_count))
        else:
            selected_questions.extend(two_weeks_questions)
        
        # Three weeks ago (10%)
        three_weeks_count = int(size * 0.1)
        three_weeks_questions = questions_by_week.get(4, [])
        if len(three_weeks_questions) > three_weeks_count:
            selected_questions.extend(random.sample(three_weeks_questions, three_weeks_count))
        else:
            selected_questions.extend(three_weeks_questions)
        
        # If not enough questions, fill with random ones
        if len(selected_questions) < size:
            remaining = size - len(selected_questions)
            all_questions = list(block_questions)
            existing_ids = {q.id for q in selected_questions}
            available = [q for q in all_questions if q.id not in existing_ids]
            
            if available:
                selected_questions.extend(random.sample(
                    available, min(remaining, len(available))
                ))
        
        return selected_questions[:size]
    
    @staticmethod
    def compose_mistakes_session(
        user,
        block_id: Optional[str] = None,
        size: int = 20
    ) -> List[Question]:
        """
        Compose a session focusing on frequently missed questions.
        """
        # Get questions with incorrect streaks
        mistake_states = UserQuestionState.objects.filter(
            user=user,
            streak_incorrect__gte=1
        ).order_by('-streak_incorrect', '-priority_score')
        
        if block_id:
            mistake_states = mistake_states.filter(block_context_id=block_id)
        
        # Get questions
        questions = [state.question for state in mistake_states[:size]]
        
        # If not enough mistakes, include questions with low success rate
        if len(questions) < size:
            low_success_states = UserQuestionState.objects.filter(
                user=user,
                total_attempts__gte=3
            ).annotate(
                success_rate=F('total_correct') * 1.0 / F('total_attempts')
            ).filter(success_rate__lt=0.5).order_by('success_rate')
            
            if block_id:
                low_success_states = low_success_states.filter(block_context_id=block_id)
            
            existing_ids = {q.id for q in questions}
            additional = [
                state.question for state in low_success_states 
                if state.question.id not in existing_ids
            ][:size - len(questions)]
            
            questions.extend(additional)
        
        return questions[:size]
    
    @staticmethod
    def _get_new_questions(user, block_id, topic_id, count: int) -> List[Question]:
        """Get questions the user hasn't seen before."""
        # Get all question IDs the user has seen
        seen_ids = UserQuestionState.objects.filter(
            user=user
        ).values_list('question_id', flat=True)
        
        # Query for new questions
        new_qs = Question.objects.filter(is_active=True)
        
        if block_id:
            new_qs = new_qs.filter(topic__block_id=block_id)
        if topic_id:
            new_qs = new_qs.filter(topic_id=topic_id)
        
        if seen_ids:
            new_qs = new_qs.exclude(id__in=seen_ids)
        
        return list(new_qs.order_by('difficulty', '?')[:count])
    
    @staticmethod
    def _get_random_questions(user, block_id, topic_id, count: int) -> List[Question]:
        """Get random questions from the block/topic."""
        random_qs = Question.objects.filter(is_active=True)
        
        if block_id:
            random_qs = random_qs.filter(topic__block_id=block_id)
        if topic_id:
            random_qs = random_qs.filter(topic_id=topic_id)
        
        return list(random_qs.order_by('?')[:count])

def _get_question_priority_from_state(state) -> str:
    """Helper to determine priority from UserQuestionState."""
    if (state.streak_incorrect >= 2 or 
        (state.last_correct is False and state.repetitions == 0)):
        return 'high'
    elif (state.streak_incorrect == 1 or
          (state.last_correct is True and state.last_confidence in ['guess', 'unsure'])):
        return 'medium'
    else:
        return 'low'